package com.me.common.util;

import java.util.concurrent.*;

/**
 * 并发工具类：   <p>
 * 1，cyclicBarrier.await();   <p>
 * 2，countDownLatch.await();   <p>
 * 3，semaphore.acquire();   <p>
 * 4，exchanger.exchange(value);   <p>
 *
 * @author ME
 * @date 2021/3/12
 */
public class ConcurrentUtil {

    /**
     * （可重用）在给定同步屏障上等待，和自己类似的一组线程互相等待，运动员等发令枪
     *
     * @param cyclicBarrier 同步屏障
     */
    public static void barrierAwait(CyclicBarrier cyclicBarrier) {
        try {
            cyclicBarrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    /**
     * （不可重用）在给定计数器上等待，一组线程等另外一组
     *
     * @param countDownLatch 计数器
     */
    public static void latchAwait(CountDownLatch countDownLatch) {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 从给定 Semaphore 中获取一个许可
     *
     * @param semaphore 信号量
     */
    public static void semaphoreAcquire(Semaphore semaphore) {
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 两个线程 使用给定 Exchanger 交互值
     *
     * @param exchanger 交换器
     */
    public static <V> void exchange(Exchanger<V> exchanger, V value) {
        try {
            exchanger.exchange(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
